import java.util.*;

/*
spfa求最短路
给定一个 n个点 m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1号点到 n号点的最短距离，如果无法从 1号点走到 n号点，则输出 impossible。
数据保证不存在负权回路。

输入格式
第一行包含整数 n和 m。
接下来 m行每行包含三个整数x,y,z，表示存在一条从点 x到点 y的有向边，边长为 z。

输出格式
输出一个整数，表示 1号点到 n号点的最短距离。
如果路径不存在，则输出 impossible。

数据范围
1≤n,m≤1e5,
图中涉及边长绝对值均不超过10000。

输入样例：
3 3
1 2 5
2 3 -3
1 3 4

输出样例：
2
 */
//public class Main {
//    static class pair {
//        int first;
//        int second;
//
//        public pair(int _first, int _second) {
//            first = _first;
//            second = _second;
//        }
//
//        public int first() {
//            return first;
//        }
//
//        public int second() {
//            return second;
//        }
//    }
//    static int n, m;
//    static int[] distance = new int[100010];
//    static boolean[] visited = new boolean[100010];
//    static ArrayList<ArrayList<pair>> graph = new ArrayList<>();
//
//    static void SPFA() {
//        distance[1] = 0;
//        visited[1] = true;
//        Queue<Integer> q = new LinkedList<>();
//        q.add(1);
//        while (!q.isEmpty()) {
//            int u = q.poll();
//            visited[u] = false;
//            for (pair p : graph.get(u)) {
//                int to = p.first(), dis = p.second();
//                if (distance[to] > distance[u] + dis) {
//                    distance[to] = distance[u] + dis;
//                    if (!visited[to])
//                        q.add(to);
//                }
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        n = sc.nextInt();
//        m = sc.nextInt();
//        for (int i = 0; i <= n; i++) {
//            distance[i] = 0x3f3f3f3f;
//            graph.add(new ArrayList<>());
//        }
//        for (int i = 1; i <= m; i++) {
//            int x = sc.nextInt(), y = sc.nextInt(), z = sc.nextInt();
//            graph.get(x).add(new pair(y, z));
//        }
//        SPFA();
//        if (distance[n] > 0x3f3f3f3f / 2) System.out.println("impossible");
//        else System.out.println(distance[n]);
//    }
//}

/*
spfa判断负环
给定一个 n个点 m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。

输入格式
第一行包含整数 n和 m。
接下来 m行每行包含三个整数 x,y,z，表示存在一条从点 x到点 y的有向边，边长为 z。

输出格式
如果图中存在负权回路，则输出 Yes，否则输出 No。

数据范围
1≤n≤2000,1≤m≤10000,
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 -1
2 3 4
3 1 -4

输出样例：
Yes
 */

public class Main {
    static class pair {
        int first;
        int second;

        public pair(int _first, int _second) {
            first = _first;
            second = _second;
        }

        public int first() {
            return first;
        }

        public int second() {
            return second;
        }
    }

    static int n, m;
    static int[] distance = new int[2010];
    static boolean[] visited = new boolean[2010];
    static int[] path = new int[2010];
    static ArrayList<ArrayList<pair>> graph = new ArrayList<>();

    static boolean SPFA() {
        //判断负环时，不需要初始化距离为正无穷，但需要把每个点都加到队列中
        Queue<Integer> q = new LinkedList<>();
        for (int i = 1; i <= n; i++) {
            q.add(i);
            visited[i] = true;
        }
        while (!q.isEmpty()) {
            int u = q.poll();
            visited[u] = false;
            for (pair p : graph.get(u)) {
                int to = p.first(), dis = p.second();
                if (distance[to] > distance[u] + dis) {
                    distance[to] = distance[u] + dis;
                    path[to] = path[u] + 1;
                    if (path[to] >= n) return true;
                    if (!visited[to])
                        q.add(to);
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int i = 1; i <= m; i++) {
            int x = sc.nextInt(), y = sc.nextInt(), z = sc.nextInt();
            graph.get(x).add(new pair(y, z));
        }

        if (SPFA()) System.out.println("Yes");
        else System.out.println("No");
    }
}